Dann starten wir da schon mal. Also willkommen zur Vorlesung dieser Woche in Rechneradjektur.

Ja, letzte Woche, also wir nähern uns dem Ende von Kapitel 1 und haben uns also letzte Woche

nochmal beschäftigt mit den Möglichkeiten, wie kann man Casheffekte entsprechend ausnutzen,

Schleifenfusion, Schleifenmerging, solche Sachen, Struct of Arrays statt Array of Structs.

Struct of Arrays statt Array of Structs statt Struct of Array. Und ja, und dann haben wir hier

nochmal genau das Cashblocking. Max hat mir gesagt, Cashblocking haben Sie auch in den Übungen

jetzt schon mal gemacht und haben Sie das nochmal durch selbst ein Beispiel ausprobiert.

Okay, ich habe Ihnen den Artikel jetzt auch nochmal von dem Lahm ins Stutt-On gelegt.

Wo ist er denn? Hier ist er. Also hier habe ich ihn einfach zitiert. Diese Grafik ist aus dem

Artikel da rausgenommen. Da können Sie ja auch, also der ist schon ein bisschen kompliziert,

hat ungefähr 10 Seiten oder sowas. Also wenn Sie die ersten 2, 3 Seiten lesen,

weil es steht schon im Wesentlichen eine Quintessenz drin und die enthält dann auch nochmal die

Grafiken habe ich nochmal entsprechend ein bisschen anders aufbearbeitet hier. Ja,

okay, gut. Was ich Ihnen jetzt nochmal zeigen wollte, bevor wir heute das Thema abschließen,

um mir uns dann nochmal der Cash-Kohärenz, ein ganz wichtiges Thema zuwenden, wollte ich Ihnen

selbst nochmal ein paar Beispiele zeigen und die habe ich Ihnen anhand von Programmen. So gehen wir

dann mal drauf und zwar das erste, wie kann man zum Beispiel die Identität, was heißt die Identität,

die Spezifik an Cache-Eigenschaften auslesen, die entsprechend spezifiziert, mit der der Cash

spezifiziert ist. Und zwar gibt es dazu einen Assembler-Befiel, der nennt sich CPU-ID und mit

dem kann ich bestimmte Information über die CPU erfragen. Fragen Sie jetzt nicht genau,

was da alles geht. Ich habe selbst auch jetzt nur ein anderem Beispiel gefunden und ja,

das funktioniert also wie folgt. Ich werde das Ganze jetzt hier dann von einem C-Programm aus

aufrufen und dazu brauche ich dann, dann bin ich von diesem C-Programm dann auch wieder auf die

vier Register, die der Inter 80 x86 da bietet, zugreifen kann, definiere ich mir hier vier Variablen,

eax, ebx, ecx und edx. Und in eine dieser Variablen übergebe ich dann eine Information,

was ich von CPU-ID auslesen möchte. Und wenn ich da ins Register A eine 4 reinschreibe, dann kriege

ich die Information über den Cash. Wenn ich da was anderes reinschreibe, kriege ich Information über

andere Einheiten. Gut, ja und ecx, das ist die Cash-ID, die dann später auch ausgelesen wird.

Das ist dann die ID, um welchen Ebene, um welches Level, dass sich der Cash, welchen Cash wieder

ansprechen. So, okay und dann ist es, so kann ich in C-Programm ein Assemblerbefehl starten,

dass es wie er heißt und das sind die Register, die ich hier übergebe und dann kriege ich im

A-Register wieder Information zurück und die maskiere ich hier eben aus, 1ff und damit kriege ich

die Information des Cash-Typs, das ist dann entsprechend kodiert. Wenn das Ganze, sie sehen,

läuft in einer Schleife und wenn, ja genau, also ich will die erste ID, die Level 0-Cash,

auslesen und wenn das Ganze vom Cash-Typ in Wert 0 zurückgibt, dann gibt es keine Cash-Chirarchien

mehr und dann breche ich die Schleife hier ab. Gut, ja und dann kommt hier unten eine ganze Latte

von, noch nicht ganz, die kommt noch weiter unten, eine Switch-Anweisung anhand des Typs kann ich

jetzt dann eben entscheiden, ja ist es ein Daten-Cash, ein Instruktions-Cash, ist es ein Unified-Cash

oder ist der Cash-Typ unbekannt an der Stelle, das sage ich Ihnen später, wenn ich ganz zufrieden

möglicherweise ist das Programm an der Stelle, dann habe ich es ganz richtig. Ja und jetzt kann

ich dadurch, dass ich weitere Bits hier ausmaskiere aus dem A-Register, bestimmte Information eben

auslesen und ja zum Beispiel, ob der Cash selbst initialisierend ist, also ob die Werte, die Einträge

alle mit 0 zum Beispiel vorbelegt, aber voll assoziativ ist und ja noch ein paar Dinge mehr,

wie viel Mengen das enthält, wie groß das die Cash-Zeile ist, ist die vielleicht noch

mal selbst in Partitionen unterteilt und wie groß ist der gerade Assoziativität. Also alles,

indem ich das EB-Register bzw. das EC-Register hier entsprechend abgreife. Ja, dann wird das Ganze

hier am Ende heute noch mal ausgelesen. Gut, dann schauen wir noch mal nach, was man Cash da so bietet.

Okay, Sie müssen diesen Assemblerbefehl starten. CPU-ID, die ganzen Wahlseiten hier, die stehen auch

noch mal in einem von den Intel Handbüchern. Könnte sein, dass der Pfad dann nicht mehr ganz

stimmt, aber dann gucken Sie einfach mal nach 32.5462.pdf und Intel, dann findet ihr das irgendwo